/*-
 * ============LICENSE_START=======================================================
 * SDC
 * ================================================================================
 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
 * ================================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ============LICENSE_END=========================================================
 */
package org.openecomp.sdc.be.config;

import org.openecomp.sdc.common.config.AbsEcompErrorManager;
import org.openecomp.sdc.common.config.EcompErrorEnum;
import org.openecomp.sdc.common.config.IEcompConfigurationManager;

public class BeEcompErrorManager extends AbsEcompErrorManager {

    private static volatile BeEcompErrorManager instance;
    private static ConfigurationManager configurationManager;

    private BeEcompErrorManager() {
    }

    public static BeEcompErrorManager getInstance() {
        if (instance == null) {
            synchronized (BeEcompErrorManager.class) {
                if (instance == null) {
                    instance = init();
                }
            }
        }
        return instance;
    }

    private static synchronized BeEcompErrorManager init() {
        if (instance == null) {
            instance = new BeEcompErrorManager();
            configurationManager = ConfigurationManager.getConfigurationManager();
        }
        return instance;
    }

    @Override
    public IEcompConfigurationManager getConfigurationManager() {
        return configurationManager;
    }

    public void logBeUebAuthenticationError(String context, String reason) {
        processEcompError(context, EcompErrorEnum.BeUebAuthenticationError, reason);
    }

    public void logBeHealthCheckRecovery(String context) {
        processEcompError(context, EcompErrorEnum.BeHealthCheckRecovery);
    }

    public void logBeHealthCheckJanusGraphRecovery(String context) {
        processEcompError(context, EcompErrorEnum.BeHealthCheckJanusGraphRecovery);
    }

    public void logBeHealthCheckUebClusterRecovery(String context) {
        processEcompError(context, EcompErrorEnum.BeHealthCheckUebClusterRecovery);
    }

    public void logDmaapHealthCheckError(String context) {
        processEcompError(context, EcompErrorEnum.DmaapHealthCheckError);
    }

    public void logUserSessionExpiredError(String context) {
        processEcompError(context, EcompErrorEnum.SessionExpiredAuthenticationError);
    }

    public void logDmaapHealthCheckRecovery(String context) {
        processEcompError(context, EcompErrorEnum.DmaapHealthCheckRecovery);
    }

    public void logFeHealthCheckRecovery(String context) {
        processEcompError(context, EcompErrorEnum.FeHealthCheckRecovery);
    }

    public void logBeHealthCheckError(String context) {
        processEcompError(context, EcompErrorEnum.BeHealthCheckError);
    }

    public void logBeHealthCheckJanusGraphError(String context) {
        processEcompError(context, EcompErrorEnum.BeHealthCheckJanusGraphError);
    }

    public void logBeHealthCheckUebClusterError(String context) {
        processEcompError(context, EcompErrorEnum.BeHealthCheckUebClusterError);
    }

    public void logFeHealthCheckError(String context) {
        processEcompError(context, EcompErrorEnum.FeHealthCheckError);
    }

    /**
     * @param context
     * @param reason
     */
    public void logBeUebConnectionError(String context, String reason) {
        processEcompError(context, EcompErrorEnum.BeUebConnectionError, reason);
    }

    public void logBeUebUnkownHostError(String context, String host) {
        processEcompError(context, EcompErrorEnum.BeUebUnkownHostError, host);
    }

    public void logBeComponentMissingError(String context, String componentType, String name) {
        processEcompError(context, EcompErrorEnum.BeComponentMissingError, componentType, name);
    }

    public void logBeIncorrectComponentError(String context, String componentType, String name) {
        processEcompError(context, EcompErrorEnum.BeIncorrectComponentError, componentType, name);
    }

    public void logBeInvalidConfigurationError(String context, String parameterName, String parameterValue) {
        processEcompError(context, EcompErrorEnum.BeInvalidConfigurationError, parameterName, parameterValue);
    }

    public void logBeUebObjectNotFoundError(String context, String notFoundObjectName) {
        processEcompError(context, EcompErrorEnum.BeUebObjectNotFoundError, notFoundObjectName);
    }

    public void logBeDistributionEngineInvalidArtifactType(String context, String artifactType, String validArtifactTypes) {
        processEcompError(context, EcompErrorEnum.BeDistributionEngineInvalidArtifactType, artifactType, validArtifactTypes);
    }

    public void logBeMissingConfigurationError(String context, String parameterName) {
        processEcompError(context, EcompErrorEnum.BeMissingConfigurationError, parameterName);
    }

    public void logBeConfigurationInvalidListSizeError(String context, String parameterName, int listMinimumSize) {
        processEcompError(context, EcompErrorEnum.BeConfigurationInvalidListSizeError, parameterName, String.valueOf(listMinimumSize));
    }

    public void logErrorConfigFileFormat(String context, String description) {
        processEcompError(context, EcompErrorEnum.ErrorConfigFileFormat, description);
    }

    public void logBeMissingArtifactInformationError(String context, String missingInfo) {
        processEcompError(context, EcompErrorEnum.BeMissingArtifactInformationError, missingInfo);
    }

    public void logBeArtifactMissingError(String context, String artifactName) {
        processEcompError(context, EcompErrorEnum.BeArtifactMissingError, artifactName);
    }

    public void logBeUserMissingError(String context, String userId) {
        processEcompError(context, EcompErrorEnum.BeUserMissingError, userId);
    }

    public void logBeInvalidTypeError(String context, String type, String name) {
        processEcompError(context, EcompErrorEnum.BeInvalidTypeError, type, name);
    }

    public void logBeInvalidValueError(String context, String value, String name, String type) {
        processEcompError(context, EcompErrorEnum.BeInvalidValueError, value, name, type);
    }

    public void logBeArtifactPayloadInvalid(String context) {
        processEcompError(context, EcompErrorEnum.BeArtifactPayloadInvalid);
    }

    public void logBeArtifactInformationInvalidError(String context) {
        processEcompError(context, EcompErrorEnum.BeArtifactInformationInvalidError);
    }

    public void logBeDistributionMissingError(String context, String distributionName) {
        processEcompError(context, EcompErrorEnum.BeDistributionMissingError, "Distribution", distributionName);
    }

    public void logBeGraphObjectMissingError(String context, String objectType, String objectName) {
        processEcompError(context, EcompErrorEnum.BeGraphObjectMissingError, objectType, objectName);
    }

    public void logBeInvalidJsonInput(String context) {
        processEcompError(context, EcompErrorEnum.BeInvalidJsonInput);
    }

    public void logBeInitializationError(String context) {
        processEcompError(context, EcompErrorEnum.BeInitializationError);
    }

    public void logBeFailedAddingResourceInstanceError(String context, String resourceName, String serviceId) {
        processEcompError(context, EcompErrorEnum.BeFailedAddingResourceInstanceError, resourceName, serviceId);
    }

    public void logBeUebSystemError(String context, String operation) {
        processEcompError(context, EcompErrorEnum.BeUebSystemError, operation);
    }

    public void logBeDistributionEngineSystemError(String context, String operation) {
        processEcompError(context, EcompErrorEnum.BeDistributionEngineSystemError, operation);
    }

    public void logBeFailedAddingNodeTypeError(String context, String nodeType) {
        processEcompError(context, EcompErrorEnum.BeFailedAddingNodeTypeError, nodeType);
    }

    public void logBeDaoSystemError(String context) {
        processEcompError(context, EcompErrorEnum.BeDaoSystemError);
    }

    public void logBeSystemError(String context) {
        processEcompError(context, EcompErrorEnum.BeSystemError);
    }

    public void logBeExecuteRollbackError(String context) {
        processEcompError(context, EcompErrorEnum.BeExecuteRollbackError);
    }

    public void logBeFailedLockObjectError(String context, String type, String id) {
        processEcompError(context, EcompErrorEnum.BeFailedLockObjectError, type, id);
    }

    public void logBeFailedCreateNodeError(String context, String nodeName, String status) {
        processEcompError(context, EcompErrorEnum.BeFailedCreateNodeError, nodeName, status);
    }

    public void logBeFailedUpdateNodeError(String context, String nodeName, String status) {
        processEcompError(context, EcompErrorEnum.BeFailedUpdateNodeError, nodeName, status);
    }

    public void logBeFailedDeleteNodeError(String context, String nodeName, String status) {
        processEcompError(context, EcompErrorEnum.BeFailedDeleteNodeError, nodeName, status);
    }

    public void logBeFailedRetrieveNodeError(String context, String nodeName, String status) {
        processEcompError(context, EcompErrorEnum.BeFailedRetrieveNodeError, nodeName, status);
    }

    public void logBeFailedFindParentError(String context, String node, String status) {
        processEcompError(context, EcompErrorEnum.BeFailedFindParentError, node, status);
    }

    public void logBeFailedFindAllNodesError(String context, String nodeType, String parentNode, String status) {
        processEcompError(context, EcompErrorEnum.BeFailedFindAllNodesError, nodeType, parentNode, status);
    }

    public void logBeFailedFindAssociationError(String context, String nodeType, String fromNode, String status) {
        processEcompError(context, EcompErrorEnum.BeFailedFindAssociationError, nodeType, fromNode, status);
    }

    public void logBeComponentCleanerSystemError(String context, String operation) {
        processEcompError(context, EcompErrorEnum.BeComponentCleanerSystemError, operation);
    }

    public void logBeRestApiGeneralError(String context) {
        processEcompError(context, EcompErrorEnum.BeRestApiGeneralError);
    }

    public void logFqdnResolveError(String context, String description) {
        processEcompError(context, EcompErrorEnum.FqdnResolveError, description);
    }

    public void logSiteSwitchoverInfo(String context, String description) {
        processEcompError(context, EcompErrorEnum.SiteSwitchoverInfo, description);
    }

    public void logInternalAuthenticationError(String context, String description, ErrorSeverity severity) {
        if (severity == null) {
            processEcompError(context, EcompErrorEnum.InternalAuthenticationError, description);
        } else {
            switch (severity) {
                case INFO:
                    processEcompError(context, EcompErrorEnum.InternalAuthenticationInfo, description);
                    break;
                case WARNING:
                    processEcompError(context, EcompErrorEnum.InternalAuthenticationWarning, description);
                    break;
                case ERROR:
                    processEcompError(context, EcompErrorEnum.InternalAuthenticationError, description);
                    break;
                case FATAL:
                    processEcompError(context, EcompErrorEnum.InternalAuthenticationFatal, description);
                    break;
                default:
                    break;
            }
        }
    }

    public void logInternalConnectionError(String context, String description, ErrorSeverity severity) {
        if (severity == null) {
            processEcompError(context, EcompErrorEnum.InternalConnectionError, description);
        } else {
            switch (severity) {
                case INFO:
                    processEcompError(context, EcompErrorEnum.InternalConnectionInfo, description);
                    break;
                case WARNING:
                    processEcompError(context, EcompErrorEnum.InternalConnectionWarning, description);
                    break;
                case ERROR:
                    processEcompError(context, EcompErrorEnum.InternalConnectionError, description);
                    break;
                case FATAL:
                    processEcompError(context, EcompErrorEnum.InternalConnectionFatal, description);
                    break;
                default:
                    break;
            }
        }
    }

    public void logInternalDataError(String context, String description, ErrorSeverity severity) {
        if (severity == null) {
            processEcompError(context, EcompErrorEnum.InternalDataError, description);
        } else {
            switch (severity) {
                case INFO:
                    processEcompError(context, EcompErrorEnum.InternalDataInfo, description);
                    break;
                case WARNING:
                    processEcompError(context, EcompErrorEnum.InternalDataWarning, description);
                    break;
                case ERROR:
                    processEcompError(context, EcompErrorEnum.InternalDataError, description);
                    break;
                case FATAL:
                    processEcompError(context, EcompErrorEnum.InternalDataFatal, description);
                    break;
                default:
                    break;
            }
        }
    }

    public void logInvalidInputError(String context, String description, ErrorSeverity severity) {
        if (severity == null) {
            processEcompError(context, EcompErrorEnum.InvalidInputError, description);
        } else {
            switch (severity) {
                case INFO:
                    processEcompError(context, EcompErrorEnum.InvalidInputWarning, description);
                    break;
                case WARNING:
                    processEcompError(context, EcompErrorEnum.InvalidInputInfo, description);
                    break;
                case ERROR:
                    processEcompError(context, EcompErrorEnum.InvalidInputError, description);
                    break;
                case FATAL:
                    processEcompError(context, EcompErrorEnum.InvalidInputFatal, description);
                    break;
                default:
                    break;
            }
        }
    }

    public void logInternalFlowError(String context, String description, ErrorSeverity severity) {
        if (severity == null) {
            processEcompError(context, EcompErrorEnum.InternalFlowError, description);
        } else {
            switch (severity) {
                case INFO:
                    processEcompError(context, EcompErrorEnum.InternalFlowInfo, description);
                    break;
                case WARNING:
                    processEcompError(context, EcompErrorEnum.InternalFlowWarning, description);
                    break;
                case ERROR:
                    processEcompError(context, EcompErrorEnum.InternalFlowError, description);
                    break;
                case FATAL:
                    processEcompError(context, EcompErrorEnum.InternalFlowFatal, description);
                    break;
                default:
                    break;
            }
        }
    }

    public void logInternalUnexpectedError(String context, String description, ErrorSeverity severity) {
        if (severity == null) {
            processEcompError(context, EcompErrorEnum.InternalUnexpectedError, description);
        } else {
            switch (severity) {
                case INFO:
                    processEcompError(context, EcompErrorEnum.InternalUnexpectedInfo, description);
                    break;
                case WARNING:
                    processEcompError(context, EcompErrorEnum.InternalUnexpectedWarning, description);
                    break;
                case ERROR:
                    processEcompError(context, EcompErrorEnum.InternalUnexpectedError, description);
                    break;
                case FATAL:
                    processEcompError(context, EcompErrorEnum.InternalUnexpectedFatal, description);
                    break;
                default:
                    break;
            }
        }
    }

    public enum ComponentName {SERVICE, PRODUCT, VF}

    public enum ErrorSeverity {INFO, WARNING, ERROR, FATAL}
}
